package xyz.fuqufyb.aec.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import xyz.fuqufyb.aec.dao.MenuMapper;
import xyz.fuqufyb.aec.data.TableResult;
import xyz.fuqufyb.aec.entity.Menu;
import xyz.fuqufyb.aec.service.IMenuService;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @author 用户: fyb
 * @description class: MenuServiceImpl
 * @date 时间: 2021/1/29 11:23
 */
@Service("IMenuService")
public class MenuServiceImpl implements IMenuService {

    @Autowired
    private MenuMapper menuMapper;

    @Override
    public int deleteByPrimaryKey(Integer id) {

        int i = menuMapper.deleteByPrimaryKey(id);

        if (i > 0) {
            return i;
        }
        return 0;
    }

    @Override
    public int insert(Menu record) {

        int insert = menuMapper.insert(record);

        if (insert > 0) {

            return insert;
        }
        return 0;
    }

    @Override
    public int insertSelective(Menu record) {

        int i = menuMapper.insertSelective(record);

        if (i > 0) {
            return i;
        }
        return 0;
    }

    @Override
    public Menu selectByPrimaryKey(Integer id) {

        Menu menu = menuMapper.selectByPrimaryKey(id);
        if (menu != null) {
            return menu;
        }
        return null;
    }

    @Override
    public int updateByPrimaryKeySelective(Menu record) {

        int i = menuMapper.updateByPrimaryKeySelective(record);

        if (i > 0) {
            return i;
        }
        return 0;
    }

    @Override
    public int updateByPrimaryKey(Menu record) {

        int i = menuMapper.updateByPrimaryKey(record);

        if (i > 0) {

            return i;
        }
        return 0;
    }

    /**
     * 分页查询
     *
     * @return
     */
    @Override
    public TableResult getMenuList(Map<String, Object> maps) {
        String page = (String) maps.get("page");
        String limit = (String) maps.get("limit");
        if (page != null && limit != null) {
//            PageHelper.startPage(Integer.parseInt(page), Integer.parseInt(limit));
            /**
             * 获取到所有的父级 和子级
             */
            List<Menu> menus = modeMenuTree(menuMapper.getMenuList(maps), null);

            List<Menu> target = new ArrayList<>();
            /**
             * 将菜单排序
             */
            getAllMenuTree(menus, target);

            System.out.println(target);
            if (!target.isEmpty()) {
//                PageInfo<Menu> pageInfo = new PageInfo<>(target);

                return TableResult.getTableResultSuccess((long) target.size(), target);
            }
        }
        return null;
    }

    /**
     * 进行menu 排序
     *
     * @param menus
     * @param target
     */
    private void getAllMenuTree(List<Menu> menus, List<Menu> target) {
        for (Menu menu : menus) {
            target.add(menu);
            if (menu.getChildren().size() > 0) {
                getAllMenuTree(menu.getChildren(), target);
            }

        }
    }


    @Override
    public List<Menu> getMenuListUserId(Integer userId) {

        List<Menu> menus = menuMapper.getMenuListUserId(userId);
        if (!menus.isEmpty()) {
            return menus;
        }
        return null;
    }

    @Override
    public List<Integer> getMenuListRole(Integer roleId) {

        List<Integer> menuListRole = menuMapper.getMenuListRole(roleId);

        if (!menuListRole.isEmpty()) {

            return menuListRole;
        }
        return null;
    }


    /**
     * 查询所以节点
     *
     * @return
     */
    @Override
    public List<Menu> getMenuTree() {

        List<Menu> menus = menuMapper.getMenuTreeList();

        return modeMenuTree(menus, null);
    }

    /**
     * 左侧菜单栏
     *
     * @param id
     * @return
     */
    @Override
    public List<Menu> getMenuTree(Integer id) {
        /**
         * 查询出所有的子id  用集合存储
         */
        List<Integer> menuTreeIds = menuMapper.getMenuTreeIds(id);
        /**
         * 根据所以的子id  查询出所有的 父级 数据  ，不用重复 使用了union 查询
         */
        List<Menu> menuTeeNodeByMenuIds = menuMapper.getMenuTeeNodeByMenuIds(menuTreeIds);

        return modeMenuTree(menuTeeNodeByMenuIds, null);
    }


//--------------------------------处理树形结构数据---------------------------------------------------

    /**
     * 处理一级菜单  数据
     *
     * @param menus
     */
    private List<Menu> modeMenuTree(List<Menu> menus, Integer parentId) {

        List<Menu> menuList = new ArrayList<>();
        for (Menu menu : menus) {
            if (menu.getParentId() == parentId) {
                /**
                 * 调用查询当前对象中所以的自己
                 */
                getChildTree(menus, menu);
                menuList.add(menu);
            }
        }
        return menuList;
    }

    /**
     * 找寻 父级 中所有的子级
     *
     * @param menus
     * @param menu
     */
    private void getChildTree(List<Menu> menus, Menu menu) {

        List<Menu> children = new ArrayList<>();

        for (Menu m : menus) {
            if (m.getParentId() != null && m.getParentId().equals(menu.getId())) {
                children.add(m);
                if (children.size() > 0) {
                    getChildTree(menus, m);
                }
            }

        }
        menu.setChildren(children);

    }

    /**
     * 根据参数传递的父Id集合，查询出所有的子Id加父Id
     *
     * @param asList
     * @return
     */
    @Override
    public int deleteMenuIds(List<Integer> asList) {
        /**
         * 使用java递归 查询 数据
         */
        List<Menu> menus = menuMapper.getMenuTreeList();
        //暂 存储查询出所以的父类和子类的MenuId
        List<Integer> target = new ArrayList<>();
        /**
         * 查询出所有的menuId 包括 父ID
         * menus : 所以的菜单数据
         * asList:前端传递的集合Id
         * target : 暂 存储查询出所以的父类和子类的MenuId
         * getDeleteMenuChildren：递归查询方法
         */
        getDeleteMenuChildren(menus, asList, target);
        System.out.println(target);
        System.out.println(target.size());
        /**
         * 去重后的menuId: 需要删除的menuIds 数据
         */
        List<Integer> collect = target.stream().distinct().collect(Collectors.toList());

        System.out.println(collect);
        System.out.println(collect.size());
        /**
         *将所有的menuId 进行删除
         */
        int i = menuMapper.deleteMenuIds(collect);
        if (i > 0) {
            return i;
        }
        /**
         * 使用mysql递归 查询数据
         */
//        List<Integer> menuIds = getMsqlDelMenuIds(asList);
//        System.out.println(menuIds);
//        System.out.println(menuIds.size());
        return 0;
    }

    /**
     * 使用java 递归数据 查询出所有的menuId
     *
     * @param menus  所以菜单集合
     * @param menuIds 前端传递的父menuIds集合
     * @param target 暂存的集合
     */
    private void getDeleteMenuChildren(List<Menu> menus, List<Integer> menuIds, List<Integer> target) {
        //-----------------方式一 -------------------------------
        for (Integer integer : menuIds) { //遍历前端传递的参数
            //暂存 根据parentId 查询出所有子级 的id
            List<Integer> sumList = new ArrayList<>();
            /**
             * 使用所有的菜单数据 进行判断，
             */
            for (Menu menu : menus) {
                if (menu.getParentId() == integer) {
                    sumList.add(menu.getId());
                }
            }
            //如果有子级
            if (sumList != null) {
                //先存储父id
                target.add(integer);
                /**
                 *   然后在进行一个递归
                 *   menus: 菜单数据
                 *   sumList: 表示把子级集合放入
                 *   target：暂存 集合
                 */
                getDeleteMenuChildren(menus, sumList, target);
            } else {
                /**
                 * 没有子级 进行一个父Id 存值 在暂存集合
                 */
                target.add(integer);
            }
        }
        //-------------------------方式二 -------------------------
//        for (Integer integer : menuIds) {//遍历前端传递的参数
//            /**
//             * 根据前端传递的父menuIds 查询出所有的子Id 集合
//             */
//            List<Integer> ids = menuMapper.getParentId(integer);
//            //如果有子级 集合 ids
//            if (ids != null) {
//                //先存储父id
//                target.add(integer);
//                /**
//                 *   然后在进行一个递归
//                 *   ids: 表示把子级集合放入
//                 *   target：暂存 集合
//                 */
//                getDeleteMenuChildren(ids, target);
//            } else {
//                /**
//                 * 没有子级 进行一个父Id 存值 在暂存集合
//                 */
//                target.add(integer);
//            }
//        }

    }

    /**
     * 通过mysql递归查询出所有的子级id和父级id的集合数据
     *
     * @param ids
     * @return
     */
    private List<Integer> getMsqlDelMenuIds(List<Integer> ids) {
        /**
         * 需要进行一个去重
         */
        List<Integer> menuIds = menuMapper.getMsqlDelMenuIds(ids);
        /**
         * 使用java 8 去重
         */
        List<Integer> integerList = menuIds.stream().distinct().collect(Collectors.toList());

        return integerList;

    }

}
